home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / MOS / RUNTIME.D < prev    next >
Encoding:
Modula Definition  |  1990-10-18  |  9.3 KB  |  257 lines
  1. DEFINITION MODULE Runtime;              (* Juergen Mueller 26.3.85, 25.10.86 *)
  2.                                         (* Th. Tempelmann 1.12.89            *)
  3.  
  4. (* Runtime Support fuer Megamax Modula-2   /4.0/  V#025
  5.  
  6.    Real-/LongInt-/LongCard-/Set-Arithmetik,
  7.    Zuweisung fuer strukturierte Datentypen,
  8.    Standard-Prozeduren.
  9.  
  10.    Alle Prozeduren koennen mit 'JSR name' auch von Assemblerteilen
  11.    aus aufgerufen werden. Die Identifier werden automatisch in alle
  12.    Module, auch lokale, importiert.
  13. *)
  14.  
  15. FROM SYSTEM IMPORT WORD, LONGWORD, ADDRESS;
  16.  
  17. EXPORT PERVASIVE
  18.   HALT,
  19.   @LENW, @LENL, @ROTA, @SHFT, @CAP,
  20.   @FP0L, @FP1L, @FP2L, @FP3L, @FP4L, @FP5L, @FP6L, @FP7L,
  21.   @FP0H, @FP1H, @FP2H, @FP3H, @FP4H, @FP5H, @FP6H, @FP7H,
  22.   @LC2S, @LI2S, @LC2D, @LI2D, @S2LC, @S2LI, @D2LC, @D2LI,
  23.   @IMLL, @CMLL, @IDVL, @CDVL, @IMDL, @CMDL,
  24.   @IMLW, @CMLW, @IDVW, @CDVW, @IMDW, @CMDW,
  25.   @LREQ, @LRNE, @LRGT, @LRGE, @LRLT, @LRLE,
  26.   @LNEG, @LABS, @LADD, @LSUB, @LMUL, @LDIV,
  27.   @STOL, @LTOS, @SRGT, @SRGE, @SRLT, @SRLE,
  28.   @SNEG, @SABS, @SADD, @SSUB, @SMUL, @SDIV,
  29.   @FNUL, @FOPS, @FOPD, @FMVS, @FMVD, @FCPN, @FCPS, @FCPD,
  30.   @FP7S, @FP7D, @FP3S, @FP3D, @FG7S, @FG7D, @FG3S, @FG3D, @FP7M, @FG7M,
  31.   @SAND, @SXOR, @SSUM, @SDIF, @SEQL, @SLEQ, @SMEM, @EXCL, @INCL, @SIRG,
  32.   @SAN1, @SXO1, @SSU1, @SDI1, @SAN2, @SXO2, @SSU2, @SDI2,
  33.   @PS3B, @PS3W, @PS3L, @PS7B, @PS7W, @PS7L,
  34.   @CWOP, @CLOP, @COPW, @COPL,
  35.   @VFPU, @V020,
  36.   @PRIO, @LSTN, @NEWP, @TRAN, @IOTR, @IOCA, @STK1, @STK2,
  37.   @RES1, @RES2, @RES3, @RES4, @RES5, @RES6, @RES7,
  38.   @IMUL, @CMUL, @IDIV, @CDIV, @IMOD, @CMOD;
  39.  
  40.  
  41. (* Standard-Identifier *)
  42.  
  43. PROCEDURE HALT;
  44.  
  45.  
  46. (* CAP-Funktion für Variable *)
  47.  
  48. PROCEDURE @CAP;         (* D0.B:= CAP (D0.W)  -- High-Byte muß Null sein! *)
  49.  
  50.  
  51. (* FLOAT / TRUNC - Routinen *)
  52.  
  53. PROCEDURE @LC2S;      (* LC(D0.L) -> SR(D0.L) *)
  54. PROCEDURE @LI2S;      (* LI(D0.L) -> SR(D0.L) *)
  55. PROCEDURE @LC2D;      (* LC(D0.L) -> LR(A0)   *)
  56. PROCEDURE @LI2D;      (* LI(D0.L) -> LR(A0)   *)
  57. PROCEDURE @S2LC;      (* SR(D0.L) -> LC(D0.L) *)
  58. PROCEDURE @S2LI;      (* SR(D0.L) -> LI(D0.L) *)
  59. PROCEDURE @D2LC;      (* LR(A0)   -> LC(D0.L) *)
  60. PROCEDURE @D2LI;      (* LR(A0)   -> LI(D0.L) *)
  61.  
  62.  
  63. (*
  64.  * Real- und Long-Arithmetik für Megamax-Reals
  65.  *)
  66.  
  67. (* Pseudo-Register f. Reals *)
  68.  
  69. VAR @FP0L: LONGWORD; @FP0H: LONGWORD;
  70.     @FP1L: LONGWORD; @FP1H: LONGWORD;
  71.     @FP2L: LONGWORD; @FP2H: LONGWORD;
  72.     @FP3L: LONGWORD; @FP3H: LONGWORD;
  73.     @FP4L: LONGWORD; @FP4H: LONGWORD;
  74.     @FP5L: LONGWORD; @FP5H: LONGWORD;
  75.     @FP6L: LONGWORD; @FP6H: LONGWORD;
  76.     @FP7L: LONGWORD; @FP7H: LONGWORD;
  77.  
  78. (* Bei allen Real-Operationen sind die Regs D0-D2/A0-A2/FP0-FP2 frei *)
  79.  
  80. PROCEDURE @LREQ;       (*  "a = b"   (A1),(A0) -> D0 *)
  81. PROCEDURE @LRNE;       (*  "a # b"   (A1),(A0) -> D0 *)
  82. PROCEDURE @LRLE;       (*  "a <= b"  (A1),(A0) -> D0 *)
  83. PROCEDURE @LRGE;       (*  "a >= b"  (A1),(A0) -> D0 *)
  84. PROCEDURE @LRLT;       (*  "a < b"   (A1),(A0) -> D0 *)
  85. PROCEDURE @LRGT;       (*  "a > b"   (A1),(A0) -> D0 *)
  86.  
  87. PROCEDURE @LNEG;       (*  "  - a"   (A0) -> (A0) *)
  88. PROCEDURE @LABS;       (*  "  |a|"   (A0) -> (A0) *)
  89. PROCEDURE @LMUL;       (*  "a * b"   (A1),(A0) -> (A1) *)
  90. PROCEDURE @LDIV;       (*  "a / b"   (A1),(A0) -> (A1) *)
  91. PROCEDURE @LADD;       (*  "a + b"   (A1),(A0) -> (A1) *)
  92. PROCEDURE @LSUB;       (*  "a - b"   (A1),(A0) -> (A1) *)
  93.  
  94.  
  95. (* Megamax Fast Floating Point Routinen           jm 3.2.90  *)
  96.  
  97. PROCEDURE @STOL;       (* D0 -> (A0) *)
  98. PROCEDURE @LTOS;       (* (A0) -> D0 *)
  99.  
  100. PROCEDURE @SRLE;       (*  "a <= b"  D1,D0 -> D0 *)
  101. PROCEDURE @SRGE;       (*  "a >= b"  D1,D0 -> D0 *)
  102. PROCEDURE @SRLT;       (*  "a < b"   D1,D0 -> D0 *)
  103. PROCEDURE @SRGT;       (*  "a > b"   D1,D0 -> D0 *)
  104.  
  105. PROCEDURE @SNEG;       (*  "  - a"   D0 -> D0 *)
  106. PROCEDURE @SABS;       (*  "  |a|"   D0 -> D0 *)
  107.  
  108. PROCEDURE @SMUL;       (*  "a * b"   D1,D0 -> D1 *)
  109. PROCEDURE @SDIV;       (*  "a / b"   D1,D0 -> D1 *)
  110. PROCEDURE @SADD;       (*  "a + b"   D1,D0 -> D1 *)
  111. PROCEDURE @SSUB;       (*  "a - b"   D1,D0 -> D1 *)
  112.  
  113.  
  114. (*
  115.  * Real- und Long-Arithmetik für IEEE-Reals über FPU (68881/2) bei $F+
  116.  * Bei allen Routinen wird A2 zerstört.
  117.  *)
  118.  
  119. PROCEDURE @FNUL;       (* F-Instr. in D0 *)
  120. PROCEDURE @FOPS;       (* F-Instr. in D0, arg.S in D1 *)
  121. PROCEDURE @FOPD;       (* F-Instr. in D0, arg.D in (A0) *)
  122. PROCEDURE @FMVS;       (* F-Instr. in D0, FP.S nach (A0) *)
  123. PROCEDURE @FMVD;       (* F-Instr. in D0, FP.D nach (A0) *)
  124. PROCEDURE @FCPN;       (* F-Instr. in D0, Cond. in D2 *)
  125. PROCEDURE @FCPS;       (* F-Instr. in D0, Cond. in D2, arg.S in D1 *)
  126. PROCEDURE @FCPD;       (* F-Instr. in D0, Cond. in D2, arg.D in (A0) *)
  127. PROCEDURE @FP7S;       (* F-Instr. in D2, FP.S nach -(A7) *)
  128. PROCEDURE @FP7D;       (* F-Instr. in D2, FP.D nach -(A7) *)
  129. PROCEDURE @FP3S;       (* F-Instr. in D2, FP.S nach (A3)+ *)
  130. PROCEDURE @FP3D;       (* F-Instr. in D2, FP.D nach (A3)+ *)
  131. PROCEDURE @FG7S;       (* F-Instr. in D2, (A7)+ nach FP.S *)
  132. PROCEDURE @FG7D;       (* F-Instr. in D2, (A7)+ nach FP.D *)
  133. PROCEDURE @FG3S;       (* F-Instr. in D2, -(A3) nach FP.S *)
  134. PROCEDURE @FG3D;       (* F-Instr. in D2, -(A3) nach FP.D *)
  135. PROCEDURE @FP7M;       (* FMOVEM auf A7; Instr. in D0 *)
  136. PROCEDURE @FG7M;       (* FMOVEM von A7; Instr. in D0 *)
  137. PROCEDURE @VFPU;       (* Laufzeitfehler, wenn keine FPU vorhanden ist *)
  138.  
  139.  
  140. (*
  141.  * LONGCARD / LONGINT - Arithmetik
  142.  *
  143.  * Int-Routinen setzen V-Bit, Card-Routinen das Carry-Bit bei Überlauf.
  144.  * Die Long-Divisionen prüfen den Divisor selbst auf Null, bei den letzten
  145.  * vier Word-Divisionen muß der Divisor vorher entspr. geprüft werden.
  146.  *)
  147.  
  148. PROCEDURE @IMLL;       (* D0.L := D0.L * D1.L   /D2/ *)
  149. PROCEDURE @CMLL;
  150. PROCEDURE @IDVL;       (* D0.L := D0.L / D1.L   /D2/ *)
  151. PROCEDURE @CDVL;
  152. PROCEDURE @IMDL;       (* D0.L := D0.L % D1.L   /D2/ *)
  153. PROCEDURE @CMDL;
  154. PROCEDURE @IMLW;       (* D0.L := D0.L * D1.W   /D2/  (0<=D1<32768) *)
  155. PROCEDURE @CMLW;       (*                                           *)
  156. PROCEDURE @IDVW;       (* D0.L := D0.L / D1.W   /D2/  (0<D1<32768)  *)
  157. PROCEDURE @CDVW;       (*                             (D1#0)        *)
  158. PROCEDURE @IMDW;       (* D0.L := D0.L % D1.W   /D2/  (0<D1<32768)  *)
  159. PROCEDURE @CMDW;       (*                             (D1>0)        *)
  160.  
  161. (*
  162.  * Kopien auf A3/A7-Stack anlegen
  163.  * Registerbelegung: A1: source-Ptr; D1.L: anzahl in bytes/words/longs;
  164.  *  A0: Adr. f. Pointer auf kopierte Daten (nur bei A7-Stack);
  165.  *  A2 ist frei, A0/D2/A2 aber nicht!.
  166.  *)
  167. PROCEDURE @PS3B;        (* byte-weise nach A3 *)
  168. PROCEDURE @PS3W;        (* word-weise nach A3 *)
  169. PROCEDURE @PS3L;        (* long-weise nach A3 *)
  170. PROCEDURE @PS7B;        (* byte-weise nach A7 *)
  171. PROCEDURE @PS7W;        (* word-weise nach A7 *)
  172. PROCEDURE @PS7L;        (* long-weise nach A7 *)
  173.  
  174. (*
  175.  * Open Arrays m. 1 HIGH-Wert und Byte-Elementen auf Stack kopieren.
  176.  * Kopieren Ptr & High-Wert auf A3-, Daten auf A7-Stack
  177.  *)
  178. PROCEDURE @CWOP;        (* HIGH ist [0..32767] *)
  179. PROCEDURE @CLOP;        (* HIGH ist LONGCARD *)
  180.  
  181. (*
  182.  * Daten kopieren.
  183.  * Registerbelegung: A1: source-Ptr; D0: anzahl in bytes; A0: ziel-Pointer;
  184.  *)
  185.  
  186. PROCEDURE @COPW;       (* D0 ist Word, D1 frei *)
  187. PROCEDURE @COPL;       (* D0 ist Longword, D1/D2/A2 frei *)
  188.  
  189. (*
  190.  * Set-Manipulation.
  191.  *)
  192.  
  193. PROCEDURE @SAND;      (*  "s * t"   *)
  194. PROCEDURE @SXOR;      (*  "s / t"   *)
  195. PROCEDURE @SSUM;      (*  "s + t"   *)
  196. PROCEDURE @SDIF;      (*  "s - t"   *)
  197. PROCEDURE @SAN1;
  198. PROCEDURE @SXO1;
  199. PROCEDURE @SSU1;
  200. PROCEDURE @SDI1;
  201. PROCEDURE @SAN2;
  202. PROCEDURE @SXO2;
  203. PROCEDURE @SSU2;
  204. PROCEDURE @SDI2;
  205. PROCEDURE @SEQL;      (*  "s = t"  Ergebnis in Z-Flag *)
  206. PROCEDURE @SLEQ;      (*  "s <= t" Ergebnis in Z-Flag *)
  207. PROCEDURE @SMEM;      (*  "e IN s" Ergebnis in Z-Flag *)
  208. PROCEDURE @INCL;      (*  INCL (s, e) *)
  209. PROCEDURE @EXCL;      (*  EXCL (s, e) *)
  210. PROCEDURE @SIRG;      (*  INCL (s, lo..hi) *)
  211.  
  212. (*
  213.  * LENGTH-Funktionen
  214.  *   Reg-Belegung: A0: Ptr auf String; D0: HIGH (String) & Ergebnis;
  215.  *                 D1 ist frei.
  216.  *)
  217. PROCEDURE @LENW;        (* LENGTH f. Strings < 64KB *)
  218. PROCEDURE @LENL;        (* LENGTH f. Strings > 64KB *)
  219.  
  220. (*
  221.  * SHIFT/ROTATE-Funktionen
  222.  *)
  223. PROCEDURE @ROTA;  (* D0: Argument, D1: Rotierweite, D2: 7/15/31 (Arg-Breite) *)
  224. PROCEDURE @SHFT;  (* D0: Argument, D1: Schubweite,  D2: 7/15/31 (Arg-Breite) *)
  225.  
  226.  
  227. (* Coroutinen-Unterstuetzung *)
  228.  
  229. PROCEDURE @NEWP ( p: PROC; wspAddr: ADDRESS; wspSize: LONGCARD; VAR prc: ADDRESS);
  230. PROCEDURE @TRAN ( VAR resumed, new: ADDRESS );
  231. PROCEDURE @IOTR ( VAR resumed, new: ADDRESS; addr: ADDRESS );
  232. PROCEDURE @IOCA ( addr: ADDRESS );
  233. PROCEDURE @LSTN;
  234.  
  235. PROCEDURE @PRIO;  (* Priorität bei Monitor-Modulen setzen *)
  236. PROCEDURE @STK1;  (* Stack-Check mit festem $200-Space *)
  237. PROCEDURE @STK2;  (* Stack-Check mit variablem Space *)
  238.  
  239. PROCEDURE @V020;  (* Laufzeitfehler, wenn keine 68020/30/ff. vorhanden ist *)
  240.  
  241. PROCEDURE @RES1;  (* Vergleicht 8 Byte (A0) <-> (A1), Erg. in Z-Flag *)
  242. PROCEDURE @RES2;
  243. PROCEDURE @RES3;
  244. PROCEDURE @RES4;
  245. PROCEDURE @RES5;
  246. PROCEDURE @RES6;
  247. PROCEDURE @RES7;
  248.  
  249. PROCEDURE @IMUL (a,b: LONGINT ): LONGINT;  (*  "a * b"    *)
  250. PROCEDURE @CMUL (a,b: LONGCARD): LONGCARD; (*  "a * b"    *)
  251. PROCEDURE @IDIV (a,b: LONGINT ): LONGINT;  (*  "a div b"  *)
  252. PROCEDURE @CDIV (a,b: LONGCARD): LONGCARD; (*  "a div b"  *)
  253. PROCEDURE @IMOD (a,b: LONGINT ): LONGINT;  (*  "a mod b"  *)
  254. PROCEDURE @CMOD (a,b: LONGCARD): LONGCARD; (*  "a mod b"  *)
  255.  
  256. END Runtime.
  257.